package org.example.day;

import java.util.ArrayList;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.stream.Collectors;

/**
 * @Description: TODO
 * @Author wyatt
 * @Data 2024/05/29 9:31
 */
//给你一个仅由小写英文字母组成的字符串 s 。
//
// 如果一个字符串仅由单一字符组成，那么它被称为 特殊 字符串。例如，字符串 "abc" 不是特殊字符串，而字符串 "ddd"、"zz" 和 "f" 是特殊字
//符串。
//
// 返回在 s 中出现 至少三次 的 最长特殊子字符串 的长度，如果不存在出现至少三次的特殊子字符串，则返回 -1 。
//
// 子字符串 是字符串中的一个连续 非空 字符序列。
//
//
//
// 示例 1：
//
//
//输入：s = "aaaa"
//输出：2
//解释：出现三次的最长特殊子字符串是 "aa" ：子字符串 "aaaa"、"aaaa" 和 "aaaa"。
//可以证明最大长度是 2 。
//
//
// 示例 2：
//
//
//输入：s = "abcdef"
//输出：-1
//解释：不存在出现至少三次的特殊子字符串。因此返回 -1 。
//
//
// 示例 3：
//
//
//输入：s = "abcaba"
//输出：1
//解释：出现三次的最长特殊子字符串是 "a" ：子字符串 "abcaba"、"abcaba" 和 "abcaba"。
//可以证明最大长度是 1 。
//
//
//
//
// 提示：
//
//
// 3 <= s.length <= 50
// s 仅由小写英文字母组成。
//
//
// Related Topics 哈希表 字符串 二分查找 计数 滑动窗口 👍 15 👎 0

public class Solution2981 {

    public static void main(String[] args) {
        Solution2981 solution2981 = new Solution2981();
        System.out.println(solution2981.maximumLength("aaaabcaabaaa"));
    }

    public int maximumLength(String s) {
        //1. 先按照字母出现次数 > 3 找出特殊子串
        //2. 再根据字母起始+重复的长度，找出长度最大的三组
        //3. 从1~3组数据中，计算最大长度

        HashMap<Character, Integer> countMap = new HashMap<>();
        HashMap<Character, List<Integer>> indexMap = new HashMap<>();

        Character prev = null;
        for(Character c : s.toCharArray()){
            countMap.putIfAbsent(c, 0);
            countMap.put(c, countMap.get(c) + 1);
            indexMap.putIfAbsent(c, new ArrayList<>());
            if(prev == null){
                List<Integer> curList = indexMap.get(c);
                curList.add(1);
            }else if(prev == c){
                List<Integer> prevList = indexMap.get(c);
                prevList.set(prevList.size()-1, prevList.get(prevList.size()-1) + 1);
            }else {
                List<Integer> curList = indexMap.get(c);
                curList.add(1);
            }
            prev = c;
        }

        int max = -1;

        List<Character> specList = new ArrayList<>();
        countMap.forEach( (key, value) -> {
            if(value >= 3){
                specList.add(key);
            }
        });

        if(specList.size() == 0){
            return max;
        }

        for(Character character : specList){
            List<Integer> appearList = indexMap.get(character);
            int subMax = getMaxAppear(appearList);
            max = Math.max(max, subMax);
        }

        return max;
    }

    private int getMaxAppear(List<Integer> appearList) {
        //取前三个最大的连续段
        if(appearList.size() > 3){
            appearList.sort(new Comparator<Integer>() {
                @Override
                public int compare(Integer o1, Integer o2) {
                    return o2-o1;
                }
            });
            appearList = appearList.subList(0,3);
        }

        List<Integer> lenList = new ArrayList<>();
        for (int len : appearList ) {
            int index = 0;
            while (len > 0 && index < 3){
                lenList.add(len);
                index++;
                len--;
            }
        }
        lenList = lenList.stream().sorted(Comparator.reverseOrder()).collect(Collectors.toList());
        return lenList.get(2);
    }

}
